web apps

Pike Conference 2006 Update

Sun, 8 Oct 2006 11:15:28 -0400

This year's Pike Conference is rapidly approaching, but there's still time to attend or participate! A lot of exciting things have been happening in the Pike world since our last meeting two years ago. We've got some very interesting presentations, discussions and activities on tap, so if you're still deciding whether to attend, consider this a nudge in the direction of Riga. :) A free, in-depth Pike tutorial session will also run concurrently with the conference, so if you're new to Pike, or you'd like to brush up on your Pike coding skills, this is a perfect opportunity.

For those of you that may have missed the original announcement, this year's Pike Conference will be held in beautiful Riga, Latvia, from October 18 through the 22nd. Riga's old town was named a UNESCO World Heritage Site, and getting to and from Riga has never been easier. For more information, send an email to the conference coordinators at conference at gotpike dot org, or visit the conference website at:

http://conference.gotpike.org

If you know you'll attending, but haven't registered yet, please take a moment to do so now, as it allows the conference team to better plan activities to suit your interests and schedule. Also, we still have spaces for participants; so if you'd like to make a presentation, suggest a topic for group discussion or just want to say a few words in person, do let us know, as we'd love to include you in the program.

I'm personally very excited about getting to meet everyone (again, even). We always have a good time and a lot of good information is passed around. If you're thinking that maybe you'd like to get more involved with your language of choice, you probably won't find a better chance to chat with like minded folks. Additionally, I've got some very cool things to talk about, so I hope to see you in Riga!

Fins and FinScribe update

Wed, 12 Jul 2006 18:40:01 -0400

I've been working on Fins and FinScribe quite a bit lately, and some interesting things have been brewing.

First, in the eye-candy department, I started working with Dojo 0.3.1, which has some better widgets than previous releases. It adds some quirks, especially with the DHTML effects, but hopefully we'll be able to work through them. I also added a new widget called RTEditor, which extends the Rich text editor widget to be tabbed: one tab is allows you to edit text in Rich Text format, and the other tab lets you edit the raw text. As you change from tab to tab, the version from the other tab is brought along with you, so you don't lose content. It's pretty neat, and lets users who are more comfortable with HTML tweak their content.

Second, on the Fins side of things, I've added some developer admin tools. We're hooking into the pike -x command, and so far, a new application creation tool is available, as well as a replacement for fin_serve, which should make it easier to run your Fins apps.

Most significant, though, is automatic configuration of Model objects by examination of the database schema. This means that if you write your database to follow the rules that Fins expects, you don't have to write Model code. It's all done for you… just create a (more or less empty) class for each datatype, and Fins will handle the rest… it's pretty cool. It's also completely optional. If you've got legacy databases to work with, Fins can also use those, but you'll have to resort to increasingly manual tactics.

New FinScribe release: 0.6

Tue, 27 Jun 2006 15:25:11 -0400

I'm pleased to announce the release of a new version of the FinScribe wiki/blog application. Version 0.6 includes a fair number of new features, most importantly the ability to modify and apply ACLs to documents. The application (especially the administration interface) include some very nifty AJAX widgets made possible by using the Dojo widget framework.

FinScribe is built on the MVC framework I've been writing, called Fins, and is written in Pike with support for mysql, sqlite and (hopefully) postgresql. Originally intended as a demonstration application for that framework, FinScribe has taken on a life of its own.

New AJAX sample application for Fins

Tue, 25 Apr 2006 14:27:39 -0400

I was surfing around the other day and ran across a little screencast[1] on the Ruby on Rails website. The point of the screencast was basically demonstrating how to create an AJAX application in a few minutes using Rails and Prototype (a javascript library). Well, obviously Ruby doesn't have the market cornered on ease of development. We in the Pike world have options, too.

So, last night I threw together the Fins[2] equivalent that searches SmugMug[3] for images and returns the results to you. It's functionally equivalent to the Rails demo application that uses Flickr.

A running instance of the sample app can be found here:

http://buoy.riverweb.com:9098/

The code is available here:

http://hww3.riverweb.com/dist/Fins/samples

You'll note that most of the bulk of the download consists of the Dojo[4] javascript library we're using to achieve some of the client side functionality. You'll also need to download Fins, which can be found in the directory immediately above. Simply untar both files, and run


./fin_serve.pike -p yourportnumber /path/to/smugmug

If you don't have the Public.Image.SmugMug and Public.Web.RSS modules, this app won't do much for you, but that's sort of beside the point.

The only other difference between the amount of work required to achieve the pike version is that you're responsible for doing a lot of the javascript work yourself. I'm not sure how I feel about the Rails way of doing things, which is to say there's a lot of magic involved. I suppose it might be worthwhile to build some convenience functions that make some of this easier.

As always, comments and suggestions are welcome!

[1] http://media.rubyonrails.org/video/flickr-rails-ajax.mov
[2] http://hww3.riverweb.com/space/pike/Fins
[3] http://www.smugmug.com
[4] http://www.dojotoolkit.org

A custom Dojo widget

Tue, 21 Feb 2006 20:57:53 -0500

I've been playing around with Dojo for the past few weeks, using it to add some rich functionality to the FinScribe application. In addition to having a number of useful methods that are useful for general Javascript projects, Dojo includes a pretty nifty widget system. http://www.dojotoolkit.org includes a number of pre-written widgets, including a cool "fisheye list" that's similar to the effect you get from the Mac OSX dock. The widget system also allows you to enhance and create new widgets outside of the Dojo core distribution.

One of the itches that I've found myself scratching over the years is the idea of what I'll call the "add/remove membership" widget. Really a compound widget, it's the one you typically see when there's a list of potential members and a list of members and a set of buttons that let you add or remove members (http://hww3.riverweb.com/hdadmin/screenshots/usergroup.png. I've implimented this in HTML and GTK on more than one occasion, but haven't ever really been happy with the result. One of the big problems is that my previous attempts weren't atomic. By atomic, I mean that you can make a number of changes to the list and then either commit or cancel.

FinScribe's administration interface includes a user and group management tool, so once again, I find myself in need of this imfamous widget. My bright idea was to develop a generic widget using Dojo that I can then use for multiple purposes. The problem with writing Dojo widgets is that there's little in the way of documentation that will be helpful. http://dojotoolkit.org/docs/fast_widget_authoring.html and http://www.richardrodger.com/roller/page/richard/Weblog/dojo_progress have both written some material, but for the most part, you're in uncharted territory. Reading through the dojo source is a critical component, and it really helps to have a good understanding of Javascript and its approach to object orientation (which I don't really posess.) Nevertheless, after a day of playing around, I think I came up with a workable solution.

The new widget, which I call a ComboPicker (yes, I know it's a dumb name) is generic and atomic. It takes a pair of methods that are used to supply the "possible members" and "current members" pool. The cool thing is that the widget makes sure that a given entry will appear in only one of the two lists at any given time. It also keeps track of the additions and removals based on the original state of the membership pool. On the output side, there are methods that can be used to get the additions and deletions, and if you place the widget in a form, the ComboPicker can hook into the form and populate a pair of input fields with the list of changes. I've added the widget to FinScribe, and you can see it in the edit groups feature in the admin interface.

Future directions might include the ability to order the members list (for use in situations where order is significant). You can download a ZIP file with the latest version from CVS, and check out the ComboPicker widget page for an example of its use. After this experience working with Dojo on a relatively complex UI component, I have to say I'm even more impressed with the Dojo event and widget systems. This is really powerful software.

Themes arrive for FinScribe

Tue, 4 Apr 2006 17:54:32 -0400

For a while now, I've been aware of the fact that not everyone likes the look of the out of the box theme for FinScribe. Heck, I don't even like it, but I'm busy with other, more important work. The problem has been that, up until today, it's been pretty difficult to change the look and feel without doing some mucking around in the core code. It's true that there was a certain amount of flexibility by changing the stylesheets (ala http://snipsnap.org), but you could only go so far with it.

Just checked into CVS is a set of changes to FinScribe and the underlying Fins framework that makes all of this a thing of the past. To create a new theme, simply copy create a new directory in the themes directory, and start elements of the default theme (currently located in themes/default and templates/) with files created in the new theme directory. You only need to change the files you want to be different, so if you really only want to fiddle with the weblog entry layout, you don't have to copy anything else to your theme. Once you've done that, just change the preference "site.theme" to be the name of the theme directory. Currently, that's the hard part, because there isn't a useful preference editor, so you'll have to use fin_serve in hilfe mode, or edit the database directly. But, it's far more doable than before, and you don't have to worry about really messing things up, because you can just revert to the default theme if things go wrong.

I'll try to get a new release out in the next few days, as this is a big deal. Hopefully some enterprising designers will come up with some new themes that don't look quite as ugly as the default. Well, one can wish, right?

Fins: a modern web development framework

Mon, 28 Nov 2005 22:15:40 -0500

What is Fins, and why would I want to use it?

Fins is a modern web application framework written in Pike. Fins uses the MVC design architecture, and thus is similar to Ruby on Rails.

Basically, this means that Fins is a toolkit for developing web applications (as opposed to simpler CGI scripts and such.) The MVC approach to software design splits an application into 3 sections, or areas of responsibility: the data model, event handling and coordination, and the user interface. In addition to using the MVC paradigm, Fins employs a "convention over configuration" approach, which means that if you follow a few simple patterns when developing your application, Fins will do a lot of the hard work for you.

If you're a Pike developer whose needs have moved beyond simple web scripts, Fins may be just the ticket for you. Similarly, if you're a Java (or C/C++ developer, even) who prefers a C/Java-like syntax but is frustrated by the amount of effort it takes to get simple tasks done (XML configuration files, anyone?), you should consider Pike and Fins. You'll likely be pleasantly surprised how much more efficient (and fun) working with Fins can be.

This website is powered by FinScribe, which was the original Fins technology demonstration application that's taken on a life of its own.

News

February 15, 2012 Version 0.9.5 (ZIP), containing all the necessary prerequisite modules, is now available. Updated the step by step ModelDemo.
April 20, 2010 A snapshot (Fins-0.9.zip) of the Fins framework is now available that bundles the prerequisite modules, allowing you to get started using Fins quickly.
November 16, 2009 View the slides from the Fins presentation at Copenhagen Open Source Day
October 24, 2009 Learn about Fins at Copenhagen Open Source Day
April 4, 2008 Added Acknowledgements page.
February 26, 2008 Added FinsAddins project to Mercurial. First release contains a set of components for handling user authentication.
February 15, 2008 A snapshot (Fins-0.8.zip) of the Fins framework is now available that bundles the prerequisite modules, allowing you to get started using Fins quickly.
February 27, 2007 Added an end-to-end example of getting Fins downloaded, installed and hooked to a set of database tables. Check out ModelDemo.
February 14, 2007 Updated Fins starter kit to version 0.2 of Fins. See Windows for details and download location.

Features

A semi-complete list of features is available at the Features page. More features are constantly being added, so check back often!

Getting Started

The easiest way to get started using Fins is to download the Fins/Win archive, and install that. The archive works just fine on Windows, MacOSX and Unix, and saves you the effort of having to install some of the smaller ancillary modules. Just follow the instructions at Windows.

While there are no official releases of the Fins framework, you can grab the 0.95 snapshot described above. Alternately, you can download the latest from the Mercurial repository, though there is a chance that the trunk of the tree may be non-working at any given time.

Developer Documentation

See the Developer page for additional documentation, including Module reference documentation.

Requirements

Pike 8.0 or newer
A supported database module (SQLite, MySQL or PostgreSQL). SQLite and MySQL are better tested than PostgreSQL, but we will fix any problems with the PostgreSQL support.

Additionally, if using Mercurial source:

Tools.ConfigFiles (available from modules.gotpike.org)

Note: The Fins framework will run on all platforms supported by Pike. Note that there are some minor limitations on the Windows platform, see Windows for details.

Deployment Options

There are a number of options for deployment of your Fins applications:

FinServe, a standalone HTTP server.
Caudium
FastCGI
SCGI

It should theoretically be possible to run Fins applications using CGI, however, the overhead of launching a Pike interpreter and initializing the application for each request would be prohibitively slow, so we won't entertain that option :)

We're also proud of a relatively new feature that allows Fins applications to be packaged for easy installation. Read more about it at the [ create Packaging] page.

Fins Applications

FinScribe
The ubiquitous Hello, World application, available from Mercurial.
a demo interface to SmugMug featuring AJAX functionality; download the code from samples.
a FullText XMLRPC provider using Xapian; available from my Mercurial repository.
The Model framework would lend itself nicely to all sorts of non-web applications, as well.

The Hello World and SmugMug applications are bundled with Fins in Mercurial, so if you get a snapshot, you'll be all set!

If you've developed an application using Fins, please send us a note and we'll include it here!

Future Directions

As we mentioned earlier, Fins is very early on in its development lifecycle. There's lots of room for enhancement, and plenty of opportunities for participation. Things we're thinking about for future releases include (in no particular order):

Convenience functions for easier development (see DocController for an example of this)
Administration tools (in progress)
ModelRamblings (in progress)
SOAP controller
Scaffolding (in progress)
AJAX (because everybody loves it, right? :)) Update: we have several features that make AJAX easier. See the Developer page for info.
Documentation (in progress)
A cool logo

If you're interested in helping out with any of these items, or if you have some additions for the list, we'd be glad to hear from you. Drop Bill a line at bill at welliver dot org.

Dojo: On the AJAX bandwagon

Sun, 15 Jan 2006 14:24:36 -0500

I've been playing around with some of the rapidly appearing http://ajaxian.com/archives/nine-tips-for-rich-internet-applications toolkits, in order to see what all the fuss is about. I'm generally of the opinion that client side Javascript is considerably more frustrating and less efficient for a developer than even the most inefficient server side development environments (like Java Servlets, for instance). It's hard to completely ignore Javascript, because of the "rich client" functionality you can layer on top of your existing web application. Of course, this path is frought with pitfalls like cross browser compatibility and accessibility problems , but in general, I think there are some good tools to be found.

In particular, I think the http://blog.dojotoolkit.org/2005/12/19/dojo-021 has a lot of potential. It seems to be approaching client side Javascript from a more general angle (and possibly lower level) than other frameworks like prototype or Scriptaculous. While Dojo doesn't have all of the prebuilt fancy special effects some of the other toolkits have, it does benefit from having slightly better documentation, and some really cool extra features, like client side crypto functions. It does seem to be a good bit more complex than prototype, but I think that the folks at the Dojo Foundation are aiming for a broader target.

As a test of some of the features, I've added some AJAX functionality to FinScribe over the last day or two. You'll notice that the login feature, as well as the blog post and actions butttons are all dynamic and ajax enabled. I've also added an Dojo DatePicker to the blog post form. I'm still thinking about exactly whether and how to include this type of functionality into FinScribe, as well as the Fins framework itself. It may eventually go away if I feel that it's AJAX for the sake of AJAX. Time will tell, and your comments and suggestions are welcome!